LoadLibrary 工作原理

LoadLibrary 的不同版本

LoadLibraryA 和 LoadLibraryW 都是 Windows API 函数 LoadLibrary 的不同版本，用于加载动态链接库 (DLL)。它们的主要区别在于处理字符串的方式。

LoadLibraryA: 处理的是 ANSI 字符串。ANSI 是一种字符编码标准，通常用于单字节字符集，适用于英语及其他不需要多字节字符的语言。
LoadLibraryW: 处理的是宽字符（Wide Character）字符串，通常是 UTF-16 编码。宽字符版本支持多字节字符，适用于处理包括中文在内的所有语言。

在 Windows API 中，许多函数都有 ANSI 和 Wide 版本，目的是为了兼容不同的字符编码需求。具体来说：

LoadLibraryA 接受的参数是 LPCSTR 类型，即指向一个以 null 结尾的 ANSI 字符串的指针。
LoadLibraryW 接受的参数是 LPCWSTR 类型，即指向一个以 null 结尾的宽字符字符串的指针。

示例代码：

#include <windows.h>

// 使用 ANSI 版本的 LoadLibraryA
HMODULE hModuleA = LoadLibraryA("example.dll");

// 使用宽字符版本的 LoadLibraryW
HMODULE hModuleW = LoadLibraryW(L"example.dll");

选择哪种版本？

如果应用程序主要处理 ANSI 字符串，且只需要支持英语或其他简单字符集，可以使用 LoadLibraryA。
如果应用程序需要处理多字节字符集（如中文、日文等），应使用 LoadLibraryW。

通常，使用宽字符版本是更好的选择，因为它提供了更广泛的字符集支持，更加通用和现代化。

自己实现 LoadLibrary

实现一个类似于 LoadLibrary 的功能，需要深入了解 Windows 的动态链接库加载机制。

以下是一个简化的示例，展示如何使用反射式 DLL 注入技术加载一个 DLL。这个示例假设您已经有一个反射式 DLL（即一个被编译为特定格式的 DLL，使其能够从内存中加载）。

提示

反射式 DLL 注入是一种高级技术，用于将 DLL 注入到目标进程中，而不需要在磁盘上有一个实际的 DLL 文件。

反射式 DLL 注入的基本步骤：

读取 DLL 文件到内存：将 DLL 文件内容读取到内存中。
解析 PE 头：解析 PE (Portable Executable) 头，以确定 DLL 的结构。
分配内存：在目标进程中分配内存，足以容纳 DLL 的各个部分（包括代码段、数据段等）。
复制各个部分：将 DLL 的各个部分复制到目标进程的地址空间中。
修复导入表和重定位：修复导入表（Import Table）和重定位（Relocations），确保 DLL 在新地址可以正确运行。
调用 DLL 入口点：调用 DLL 的入口点（通常是 DllMain），初始化 DLL。

示例代码

以下是一个示例代码，展示如何手动加载一个 DLL。请注意，这只是一个非常基本的实现，忽略了许多细节和错误处理。

#include <windows.h>
#include <iostream>

void* LoadDLLFromMemory(const void* dllBuffer, size_t dllSize) {
    IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)dllBuffer;
    IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)((BYTE*)dllBuffer + dosHeader->e_lfanew);
    IMAGE_SECTION_HEADER* sectionHeader = IMAGE_FIRST_SECTION(ntHeaders);

    // Allocate memory for the DLL
    void* dllBase = VirtualAlloc(NULL, ntHeaders->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (!dllBase) {
        std::cerr << "Failed to allocate memory for DLL" << std::endl;
        return nullptr;
    }

    // Copy headers
    memcpy(dllBase, dllBuffer, ntHeaders->OptionalHeader.SizeOfHeaders);

    // Copy sections
    for (int i = 0; i < ntHeaders->FileHeader.NumberOfSections; ++i) {
        void* dest = (BYTE*)dllBase + sectionHeader[i].VirtualAddress;
        void* src = (BYTE*)dllBuffer + sectionHeader[i].PointerToRawData;
        memcpy(dest, src, sectionHeader[i].SizeOfRawData);
    }

    // Resolve import table (simplified, doesn't handle all cases)
    IMAGE_DATA_DIRECTORY* importDirectory = &ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
    IMAGE_IMPORT_DESCRIPTOR* importDesc = (IMAGE_IMPORT_DESCRIPTOR*)((BYTE*)dllBase + importDirectory->VirtualAddress);

    while (importDesc->Name) {
        char* moduleName = (char*)((BYTE*)dllBase + importDesc->Name);
        HMODULE module = LoadLibraryA(moduleName);

        IMAGE_THUNK_DATA* thunk = (IMAGE_THUNK_DATA*)((BYTE*)dllBase + importDesc->FirstThunk);
        while (thunk->u1.AddressOfData) {
            IMAGE_IMPORT_BY_NAME* import = (IMAGE_IMPORT_BY_NAME*)((BYTE*)dllBase + thunk->u1.AddressOfData);
            thunk->u1.Function = (ULONGLONG)GetProcAddress(module, import->Name);
            thunk++;
        }
        importDesc++;
    }

    // Fix relocations (simplified, doesn't handle all cases)
    IMAGE_DATA_DIRECTORY* relocationDirectory = &ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
    IMAGE_BASE_RELOCATION* relocation = (IMAGE_BASE_RELOCATION*)((BYTE*)dllBase + relocationDirectory->VirtualAddress);

    DWORD delta = (DWORD)((BYTE*)dllBase - ntHeaders->OptionalHeader.ImageBase);
    while (relocation->VirtualAddress) {
        DWORD* patchAddr = (DWORD*)((BYTE*)dllBase + relocation->VirtualAddress);
        DWORD* patchEnd = (DWORD*)((BYTE*)patchAddr + relocation->SizeOfBlock);
        WORD* relocData = (WORD*)((BYTE*)relocation + sizeof(IMAGE_BASE_RELOCATION));

        while ((DWORD*)relocData < patchEnd) {
            if (*relocData >> 12 == IMAGE_REL_BASED_HIGHLOW) {
                *patchAddr += delta;
            }
            relocData++;
            patchAddr++;
        }
        relocation = (IMAGE_BASE_RELOCATION*)((BYTE*)relocation + relocation->SizeOfBlock);
    }

    // Call DLL entry point (simplified)
    typedef BOOL(WINAPI* DllEntryPoint)(HINSTANCE, DWORD, LPVOID);
    DllEntryPoint entryPoint = (DllEntryPoint)((BYTE*)dllBase + ntHeaders->OptionalHeader.AddressOfEntryPoint);
    entryPoint((HINSTANCE)dllBase, DLL_PROCESS_ATTACH, NULL);

    return dllBase;
}

int main() {
    // Load DLL from file
    HANDLE file = CreateFile("example.dll", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to open DLL file" << std::endl;
        return 1;
    }

    DWORD fileSize = GetFileSize(file, NULL);
    void* dllBuffer = malloc(fileSize);

    DWORD bytesRead;
    ReadFile(file, dllBuffer, fileSize, &bytesRead, NULL);
    CloseHandle(file);

    // Load DLL from memory
    void* dllBase = LoadDLLFromMemory(dllBuffer, fileSize);
    if (!dllBase) {
        std::cerr << "Failed to load DLL from memory" << std::endl;
        free(dllBuffer);
        return 1;
    }

    std::cout << "DLL loaded successfully" << std::endl;

    // Free allocated memory
    VirtualFree(dllBase, 0, MEM_RELEASE);
    free(dllBuffer);

    return 0;
}

解释

读取 DLL 文件到内存：打开并读取 DLL 文件内容到 dllBuffer 中。
解析 PE 头：通过 IMAGE_DOS_HEADER 和 IMAGE_NT_HEADERS 解析 DLL 的 PE 头信息。
分配内存：使用 VirtualAlloc 在当前进程的地址空间中分配内存，足以容纳 DLL 的所有部分。
复制各个部分：将 DLL 的头部和各个节（section）复制到新分配的内存中。
解析导入表：解析并修复 DLL 的导入表，以便正确调用其他 DLL 中的函数。
修复重定位：修复 DLL 的重定位条目，以确保 DLL 能够在新地址正确运行。
调用 DLL 入口点：调用 DLL 的入口点（通常是 DllMain），以初始化 DLL。
释放内存：在程序结束时，释放分配的内存。

这只是一个非常基本的实现，实际的反射式 DLL 注入会更加复杂，需要处理更多的边缘情况和错误检查。

LoadLibrary 的不同版本​

自己实现 LoadLibrary​

反射式 DLL 注入的基本步骤：​

示例代码​

解释​

LoadLibrary 的不同版本

自己实现 LoadLibrary

反射式 DLL 注入的基本步骤：

示例代码

解释